home *** CD-ROM | disk | FTP | other *** search
/ Aminet 19 / Aminet 19 (1997)(GTI - Schatztruhe)[!][Jun 1997].iso / Aminet / dev / c / vbcc.lha / vbcc / parse_expr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-12-23  |  22.2 KB  |  759 lines
  1. /*  $VER: vbcc (parse_expr.c) V0.4  */
  2.  
  3. #include "vbc.h"
  4.  
  5. static char FILE_[]=__FILE__;
  6.  
  7. np expression(void)
  8. /*  Komma-Ausdruecke                                        */
  9. {
  10.     np left,right,new;
  11.     left=assignment_expression();
  12.     if(!left->flags) return(0);
  13.     killsp();
  14.     while(*s==','){
  15.         s++;
  16.         killsp();
  17.         right=assignment_expression();
  18.         new=mymalloc(NODES);
  19.         new->left=left;
  20.         new->right=right;
  21.         new->ntyp=0;
  22.         new->flags=KOMMA;
  23.         left=new;
  24.         killsp();
  25.     }
  26.     return(left);
  27. }
  28. np assignment_expression(void)
  29. /*  Zuweisungsausdruecke                                    */
  30. {
  31.     np left,new;int c=0;
  32.     left=conditional_expression();
  33.     killsp();
  34.     if(*s!='='&&*(s+1)!='='&&*(s+2)!='=') return(left);
  35.     if(*s=='=') {c=ASSIGN;s++;} else
  36.     {if(*s=='*'&&*(s+1)=='=') {c=ASSIGNMULT;s+=2;}  else
  37.     {if(*s=='/'&&*(s+1)=='=') {c=ASSIGNDIV;s+=2;}   else
  38.     {if(*s=='%'&&*(s+1)=='=') {c=ASSIGNMOD;s+=2;}   else
  39.     {if(*s=='+'&&*(s+1)=='=') {c=ASSIGNADD;s+=2;}   else
  40.     {if(*s=='-'&&*(s+1)=='=') {c=ASSIGNSUB;s+=2;}   else
  41.     {if(*s=='&'&&*(s+1)=='=') {c=ASSIGNAND;s+=2;}   else
  42.     {if(*s=='^'&&*(s+1)=='=') {c=ASSIGNXOR;s+=2;}   else
  43.     {if(*s=='|'&&*(s+1)=='=') {c=ASSIGNOR;s+=2;}    else
  44.     {if(*s=='<'&&*(s+1)=='<') {c=ASSIGNLSHIFT;s+=3;}else
  45.     {if(*s=='>'&&*(s+1)=='>') {c=ASSIGNRSHIFT;s+=3;}else {return(left);}
  46.     }}}}}}}}}}
  47.     new=mymalloc(NODES);
  48.     new->left=left;
  49.     new->ntyp=0;
  50.     if(c==ASSIGN){
  51.         new->right=assignment_expression();
  52.         new->flags=ASSIGN;
  53.     }else{
  54.         /*  ASSIGNOP(a,b)->ASSIGN(a,OP(a,b))    */
  55.         new->flags=ASSIGNADD;   /* nur zum Merken, dass nur einmal  */
  56.                                 /* ausgewertet werden darf          */
  57.         new->right=mymalloc(NODES);
  58.         new->right->left=left;
  59.         new->right->right=assignment_expression();
  60.         new->right->ntyp=0;
  61.         if(c==ASSIGNMULT) new->right->flags=MULT;
  62.         if(c==ASSIGNDIV) new->right->flags=DIV;
  63.         if(c==ASSIGNMOD) new->right->flags=MOD;
  64.         if(c==ASSIGNADD) new->right->flags=ADD;
  65.         if(c==ASSIGNSUB) new->right->flags=SUB;
  66.         if(c==ASSIGNAND) new->right->flags=AND;
  67.         if(c==ASSIGNXOR) new->right->flags=XOR;
  68.         if(c==ASSIGNOR) new->right->flags=OR;
  69.         if(c==ASSIGNLSHIFT) new->right->flags=LSHIFT;
  70.         if(c==ASSIGNRSHIFT) new->right->flags=RSHIFT;
  71.     }
  72.     return(new);
  73. }
  74. np conditional_expression(void)
  75. /*  Erledigt ? :  momentan noch nicht implementiert         */
  76. {
  77.     np left,new;
  78.     left=logical_or_expression();
  79.     killsp();
  80.     if(*s=='?'){    /*  hier ein while  ?   */
  81.         s++;killsp();
  82.         new=mymalloc(NODES);
  83.         new->flags=COND;
  84.         new->ntyp=0;
  85.         new->left=left;
  86.         new->right=mymalloc(NODES);
  87.         new->right->flags=COLON;
  88.         new->right->ntyp=0;
  89.         new->right->left=expression();
  90.         killsp();
  91.         if(*s==':'){s++;killsp();} else error(70);
  92.         new->right->right=conditional_expression();
  93.         left=new;
  94.         killsp();
  95.     }
  96.     return(left);
  97. }
  98. np logical_or_expression(void)
  99. /*  Erledigt ||                                             */
  100. {
  101.     np left,right,new;
  102.     left=logical_and_expression();
  103.     killsp();
  104.     while(*s=='|'&&*(s+1)=='|'){
  105.         s+=2;
  106.         killsp();
  107.         right=logical_and_expression();
  108.         new=mymalloc(NODES);
  109.         new->left=left;
  110.         new->right=right;
  111.         new->flags=LOR;
  112.         new->ntyp=0;
  113.         left=new;
  114.         killsp();
  115.     }
  116.     return(left);
  117. }
  118. np logical_and_expression(void)
  119. /*  Erledigt &&                                             */
  120. {
  121.     np left,right,new;
  122.     left=inclusive_or_expression();
  123.     killsp();
  124.     while(*s=='&'&&*(s+1)=='&'){
  125.         s+=2;
  126.         killsp();
  127.         right=inclusive_or_expression();
  128.         new=mymalloc(NODES);
  129.         new->left=left;
  130.         new->right=right;
  131.         new->flags=LAND;
  132.         new->ntyp=0;
  133.         left=new;
  134.         killsp();
  135.     }
  136.     return(left);
  137. }
  138. np inclusive_or_expression(void)
  139. /*  Erledigt |                                              */
  140. {
  141.     np left,right,new;
  142.     left=exclusive_or_expression();
  143.     killsp();
  144.     while(*s=='|'&&*(s+1)!='|'&&*(s+1)!='='){
  145.         s++;
  146.         killsp();
  147.         right=exclusive_or_expression();
  148.         new=mymalloc(NODES);
  149.         new->left=left;
  150.         new->right=right;
  151.         new->flags=OR;
  152.         new->ntyp=0;
  153.         left=new;
  154.         killsp();
  155.     }
  156.     return(left);
  157. }
  158. np exclusive_or_expression(void)
  159. /*  Erledigt ^                                              */
  160. {
  161.     np left,right,new;
  162.     left=and_expression();
  163.     killsp();
  164.     while(*s=='^'&&*(s+1)!='='){
  165.         s++;
  166.         killsp();
  167.         right=and_expression();
  168.         new=mymalloc(NODES);
  169.         new->left=left;
  170.         new->right=right;
  171.         new->flags=XOR;
  172.         new->ntyp=0;
  173.         left=new;
  174.         killsp();
  175.     }
  176.     return(left);
  177. }
  178. np and_expression(void)
  179. /*  Erledigt &                                              */
  180. {
  181.     np left,right,new;
  182.     left=equality_expression();
  183.     killsp();
  184.     while(*s=='&'&&*(s+1)!='&'&&*(s+1)!='='){
  185.         s++;
  186.         killsp();
  187.         right=equality_expression();
  188.         new=mymalloc(NODES);
  189.         new->left=left;
  190.         new->right=right;
  191.         new->flags=AND;
  192.         new->ntyp=0;
  193.         left=new;
  194.         killsp();
  195.     }
  196.     return(left);
  197. }
  198. np equality_expression(void)
  199. /*  Erledigt == und !=                                      */
  200. {
  201.     np left,right,new;int c;
  202.     left=relational_expression();
  203.     killsp();
  204.     while((*s=='='||*s=='!')&&*(s+1)=='='){
  205.         if(*s=='!') c=INEQUAL; else c=EQUAL;
  206.         s+=2;
  207.         killsp();
  208.         right=relational_expression();
  209.         new=mymalloc(NODES);
  210.         new->left=left;
  211.         new->right=right;
  212.         new->flags=c;
  213.         new->ntyp=0;
  214.         left=new;
  215.         killsp();
  216.     }
  217.     return(left);
  218. }
  219. np relational_expression(void)
  220. /*  Erledigt <,>,<=,>=                                      */
  221. {
  222.     np left,right,new;int c;
  223.     left=shift_expression();
  224.     killsp();
  225.     while((*s=='<'&&*(s+1)!='<')||(*s=='>'&&*(s+1)!='>')){
  226.         if(*s++=='<'){
  227.             if(*s=='='){s++;c=LESSEQ;}else c=LESS;
  228.         }else{
  229.             if(*s=='='){s++;c=GREATEREQ;}else c=GREATER;
  230.         }
  231.         killsp();
  232.         right=shift_expression();
  233.         new=mymalloc(NODES);
  234.         new->left=left;
  235.         new->right=right;
  236.         new->flags=c;
  237.         new->ntyp=0;
  238.         left=new;
  239.         killsp();
  240.     }
  241.     return(left);
  242. }
  243. np shift_expression(void)
  244. /*  Erledigt <<,>>                                          */
  245. {
  246.     np left,right,new;int c;
  247.     left=additive_expression();
  248.     killsp();
  249.     while((*s=='<'&&*(s+1)=='<'&&*(s+2)!='=')||(*s=='>'&&*(s+1)=='>'&&*(s+2)!='=')){
  250.         if(*s=='<') c=LSHIFT; else c=RSHIFT;
  251.         s+=2;
  252.         killsp();
  253.         right=additive_expression();
  254.         new=mymalloc(NODES);
  255.         new->left=left;
  256.         new->right=right;
  257.         new->flags=c;
  258.         new->ntyp=0;
  259.         left=new;
  260.         killsp();
  261.     }
  262.     return(left);
  263. }
  264. np additive_expression(void)
  265. /*  Erledigt +,-                                            */
  266. {
  267.     np left,right,new;int c;
  268.     left=multiplicative_expression();
  269.     killsp();
  270.     while((*s=='+'||*s=='-')&&*(s+1)!='='){
  271.         if(*s++=='+') c=ADD; else c=SUB;
  272.         killsp();
  273.         right=multiplicative_expression();
  274.         new=mymalloc(NODES);
  275.         new->left=left;
  276.         new->right=right;
  277.         new->flags=c;
  278.         new->ntyp=0;
  279.         left=new;
  280.         killsp();
  281.     }
  282.     return(left);
  283. }
  284. np multiplicative_expression(void)
  285. /*  Erledigt *,/,%                                          */
  286. {
  287.     np left,right,new;int c;
  288.     left=cast_expression();
  289.     killsp();
  290.     while((*s=='*'||*s=='/'||*s=='%')&&*(s+1)!='='){
  291.         if(*s=='*') c=MULT; else {if(*s=='/') c=DIV; else c=MOD;}
  292.         s++;
  293.         killsp();
  294.         right=cast_expression();
  295.         new=mymalloc(NODES);
  296.         new->left=left;
  297.         new->right=right;
  298.         new->flags=c;
  299.         new->ntyp=0;
  300.         left=new;
  301.         killsp();
  302.     }
  303.     return(left);
  304. }
  305. np cast_expression(void)
  306. /*  Erledigt (typ)                                          */
  307. {
  308.     np new;char *imerk,buff[MAXI];
  309.     killsp();
  310.     if(*s!='('||!declaration(1)) return(unary_expression());
  311.     s++;killsp();
  312.     new=mymalloc(NODES);
  313.     new->flags=CAST;
  314.     new->right=0;
  315.     imerk=ident;ident=buff;
  316.     new->ntyp=declarator(declaration_specifiers());
  317.     ident=imerk;
  318.     killsp();
  319.     if(*s!=')') error(59); else s++;
  320.     new->left=cast_expression();
  321.     return(new);
  322. }
  323. np unary_expression(void)
  324. /*  Erledigt !,~,++,--,+,-,*,&,sizeof                       */
  325. {
  326.     np new;char *merk=s,buff[MAXI];int done=0;
  327.     killsp();
  328.     if((*s!='s'&&*s!='+'&&*s!='-'&&*s!='&'&&*s!='*'&&*s!='~'&&*s!='!')||*(s+1)=='=') return(postfix_expression());
  329.     if(*s=='s'){
  330.         merk=s;cpbez(buff,0);s=merk;
  331.         if(strcmp("sizeof",buff)) return(postfix_expression());
  332.         else{
  333.             s+=6;killsp();
  334.             new=mymalloc(NODES);
  335.             new->flags=CEXPR;
  336.             new->ntyp=mymalloc(TYPS);
  337.             new->ntyp->flags=UNSIGNED|LONG;
  338.             new->ntyp->next=0;
  339.             new->right=0;
  340.             new->left=0;
  341.             if(*s=='('&&declaration(1)){
  342.                 struct Typ *t;
  343.                 s++;killsp();
  344.                 merk=ident;ident=buff;
  345.                 t=declarator(declaration_specifiers());
  346.                 if(type_uncomplete(t)) error(176);
  347.                 ident=merk;
  348.                 new->val.vulong=zl2zul(szof(t));
  349.                 freetyp(t);
  350.                 killsp();
  351.                 if(*s!=')') error(59); else s++;
  352.             }else{
  353.                 np tree;
  354.                 killsp();
  355.                 tree=unary_expression();
  356.                 if(!tree||!type_expression(tree)){
  357.                     new->val.vulong=zl2zul(l2zl(0L));
  358.                     error(73);
  359.                 }else{
  360.                     if(type_uncomplete(tree->ntyp)) error(176);
  361.                     new->val.vulong=zl2zul(szof(tree->ntyp));
  362.                 }
  363.                 if(tree) free_expression(tree);killsp();
  364.             }
  365.             return(new);
  366.         }
  367.     }
  368.     new=mymalloc(NODES);
  369.     new->right=0;
  370.     new->ntyp=0;
  371.     if(*s=='+'&&!done)
  372.         if(*(s+1)=='+'){
  373.             s+=2;done=1;
  374.             new->left=unary_expression();
  375.             new->flags=PREINC;
  376.         }else{
  377.             s++;free(new);
  378.             return(cast_expression());
  379.         }
  380.     if(*s=='-'&&!done){
  381.         done=1;
  382.         if(*(s+1)=='-'){
  383.             s+=2;
  384.             new->left=unary_expression();
  385.             new->flags=PREDEC;
  386.         }else{
  387.             s++;
  388.             new->left=cast_expression();
  389.             new->flags=MINUS;
  390.         }
  391.     }
  392.     if(*s=='&'&&!done){
  393.         s++;done=1;
  394.         new->left=cast_expression();
  395.         new->flags=ADDRESS;
  396.     }
  397.     if(*s=='*'&&!done){
  398.         s++;done=1;
  399.         new->left=cast_expression();
  400.         new->flags=CONTENT;
  401.     }
  402.     if(*s=='~'&&!done){
  403.         s++;done=1;
  404.         new->left=cast_expression();
  405.         new->flags=KOMPLEMENT;
  406.     }
  407.     if(*s=='!'&&!done){
  408.         s++;done=1;
  409.         new->left=cast_expression();
  410.         new->flags=NEGATION;
  411.     }
  412.     new->right=0;
  413.     new->ntyp=0;
  414.     return(new);
  415. }
  416. np postfix_expression(void)
  417. /*  Erledigt [],(),.,->,++,--                                   */
  418. {
  419.     np new,left;int done;
  420.     left=primary_expression();
  421.     killsp();
  422.     while(*s=='['||*s=='('||*s=='.'||(*s=='-'&&((*(s+1)=='-')||(*(s+1)=='>')))
  423.           ||(*s=='+'&&*(s+1)=='+')){
  424.         done=0;
  425.         new=mymalloc(NODES);
  426.         new->ntyp=0;
  427.         new->right=0;
  428.         new->left=left;
  429.         if(*s=='-'){
  430.             s++;done=1;
  431.             if(*s=='-'){
  432.                 s++;
  433.                 new->flags=POSTDEC;
  434.             }else{
  435.                 s++; killsp();
  436.                 new->flags=DSTRUCT;
  437.                 new->right=identifier_expression();
  438.                 new->right->flags=MEMBER;
  439.                 new->left=mymalloc(NODES);
  440.                 new->left->ntyp=0;
  441.                 new->left->left=left;
  442.                 new->left->right=0;
  443.                 new->left->flags=CONTENT;
  444.             }
  445.         }
  446.         if(*s=='['&&!done){
  447.             s++; killsp();done=1;
  448.             new->flags=CONTENT;
  449.             new->left=mymalloc(NODES);
  450.             new->left->flags=ADD;
  451.             new->left->ntyp=0;
  452.             new->left->left=left;
  453.             new->left->right=expression();
  454.             killsp();
  455.             if(*s!=']') error(62); else s++;
  456.         }
  457.         if(*s=='+'&&!done){
  458.             s+=2;done=1;
  459.             new->flags=POSTINC;
  460.         }
  461.         if(*s=='.'&&!done){
  462.             s++;killsp();done=1;
  463.             new->right=identifier_expression();
  464.             new->flags=DSTRUCT;
  465.             new->right->flags=MEMBER;
  466.         }
  467.         if(*s=='('&&!done){
  468.             struct argument_list *al,*first_alist=0,*last_alist=0;np n;
  469.             s++;killsp();done=1;
  470.             new->flags=CALL;
  471.             new->right=0;
  472.             while(*s!=')'){
  473.                 n=assignment_expression();
  474.                 al=mymalloc(sizeof(struct argument_list));
  475.                 al->arg=n;al->next=0;
  476.                 if(last_alist){
  477.                     last_alist->next=al;
  478.                     last_alist=al;
  479.                 }else{
  480.                     last_alist=first_alist=al;
  481.                 }
  482.                 killsp();
  483.                 if(*s==',') {s++;killsp();if(*s==')') error(59);} /* hier noch strenger */
  484.             }
  485.             new->alist=first_alist;
  486.             if(*s!=')') error(59); else s++;
  487.         }
  488.         left=new;
  489.         killsp();
  490.     }
  491.     return(left);
  492. }
  493. np primary_expression(void)
  494. /*  Hier fehlt noch allerhand                               */
  495. {
  496.     np new;
  497.     if((*s>='0'&&*s<='9')||*s=='.') return(constant_expression());
  498.     if(*s=='\"'||*s=='\''||(*s=='L'&&(*(s+1)=='\''||*(s+1)=='\"'))) return(string_expression());
  499.     if(*s=='('){
  500.         s++;killsp();
  501.         new=expression();
  502.         killsp();
  503.         if(*s!=')') error(59); else s++;
  504.         return(new);
  505.     }
  506.     return(identifier_expression());
  507. }
  508. np string_expression(void)
  509. /*  Gibt Zeiger auf string oder Zeichenkonstante zurueck    */
  510. {
  511.     np new; char f,string[MAXINPUT],*p;int flag,val;zlong zl;
  512.     if(*s=='L') s++;    /*  Noch keine erweiterten Zeichen  */
  513.     p=string;f=*s++;
  514.     while(1){
  515.         while(*s!=f&&p<&string[MAXINPUT-1]){
  516.             if(*s=='\\'){
  517.                 s++;
  518.                 if(*s=='\\'){*p++='\\';s++;continue;}
  519.                 if(*s=='n'){*p++='\n';s++;continue;}
  520.                 if(*s=='t'){*p++='\t';s++;continue;}
  521.                 if(*s=='r'){*p++='\r';s++;continue;}
  522.                 if(*s=='v'){*p++='\v';s++;continue;}
  523.                 if(*s=='b'){*p++='\b';s++;continue;}
  524.                 if(*s=='f'){*p++='\f';s++;continue;}
  525.                 if(*s=='a'){*p++='\a';s++;continue;}
  526.                 if(*s=='\?'){*p++='\?';s++;continue;}
  527.                 if(*s=='\''){*p++='\'';s++;continue;}
  528.                 if(*s=='\"'){*p++='\"';s++;continue;}
  529.                 flag=val=0;
  530.                 while(*s>='0'&&*s<='7'&&flag<3){
  531.                     val=val*8+*s-'0';
  532.                     s++;flag++;
  533.                 }
  534.                 if(flag){*p++=val;continue;}
  535.                 if(*s=='x'){
  536.                     s++;val=0;
  537.                     while((*s>='0'&&*s<='9')||(*s>='a'&&*s<='f')||(*s>='A'&&*s<='F')){
  538.                         val=val*16;
  539.                         if(*s>='0'&&*s<='9') val+=*s-'0';
  540.                         if(*s>='a'&&*s<='f') val+=*s-'a'+10;
  541.                         if(*s>='A'&&*s<='F') val+=*s-'A'+10;
  542.                         s++;
  543.                     }
  544.                     *p++=val;continue;
  545.                 }
  546.                 error(71);
  547.             }
  548.             *p++=*s++;
  549.         }
  550.         if(*s!=f) error(74); else s++;
  551.         killsp();
  552.         if(f!='\"'||*s!=f) break; else s++;
  553.     }
  554.     *p=0;
  555.     new=mymalloc(NODES);
  556.     new->ntyp=mymalloc(TYPS);
  557.     if(f=='\"'){
  558.         struct const_list *cl,**prev;int i;
  559.         new->ntyp->flags=ARRAY;
  560.         new->ntyp->size=l2zl((long)(p-string)+1);
  561.         new->ntyp->next=mymalloc(TYPS);
  562.         new->ntyp->next->flags=STRINGCONST|CHAR;
  563.         new->ntyp->next->next=0;
  564.         new->flags=STRING;
  565.         prev=(struct const_list **)&new->identifier;
  566.         for(i=0;i<p-string+1;i++){
  567.             cl=mymalloc(CLS);
  568.             cl->next=0;
  569.             cl->tree=0;
  570.             cl->other=mymalloc(CLS);
  571.             cl->other->next=cl->other->other=0;
  572.             cl->other->tree=0;
  573.             cl->other->val.vchar=zl2zc(l2zl((long)string[i]));
  574.             *prev=cl;
  575.             prev=&cl->next;
  576.         }
  577. /*        new->identifier=add_identifier(string,p-string);*/
  578.         new->val.vlong=l2zl(0L);
  579.     }else{
  580.         char *l;
  581.         new->ntyp->flags=CONST|INT;
  582.         new->ntyp->next=0;
  583.         new->flags=CEXPR;
  584.         zl=l2zl(0L);
  585.         p--;
  586.         if(p>string) error(72);
  587.         for(BIGENDIAN?(l=string):(l=p);BIGENDIAN?(l<=p):(l>=string);BIGENDIAN?(l++):(l--)){
  588.             /*  zl=zl<<CHAR_BIT+*p  */
  589.             zl=zllshift(zl,char_bit);
  590.             zl=zladd(zl,l2zl((long)*l));
  591.             new->val.vint=zl2zi(zl);
  592.         }
  593.     }
  594.     new->left=new->right=0;
  595.     return(new);
  596. }
  597. np constant_expression(void)
  598. /*  Gibt Zeiger auf erzeugt Struktur fuer Konstante zurueck */
  599. /*  Es werden die Werte aus <limits.h> benutzt.             */
  600. {
  601.     np new; zdouble db;
  602.     zulong value,zbase,digit;unsigned long base=10,t;
  603.     char *merk;int warned=0;
  604.     merk=s;
  605.     value=ul2zul(0L);
  606.     new=mymalloc(NODES);
  607.     new->ntyp=mymalloc(TYPS);
  608.     new->ntyp->flags=0;
  609.     new->ntyp->next=0;
  610.     new->flags=CEXPR;
  611.     new->left=new->right=0;
  612.     new->sidefx=0;
  613.     if(*s=='0'){
  614.         s++;
  615.         if(*s=='x'||*s=='X'){s++;base=16;} else base=8;
  616.     }
  617.     zbase=ul2zul(base);
  618.     if(*s>='0'&&*s<='9') t=*s-'0'; else{
  619.     if(*s>='a'&&*s<='f') t=*s-'a'+10; else{
  620.     if(*s>='A'&&*s<='F') t=*s-'A'+10; else{t=20;}}}
  621.     while(t<base){
  622.         digit=ul2zul(t);
  623.         if(!warned){
  624.             if(!zulleq(value,zuldiv(zulsub(t_max[UNSIGNED|LONG],digit),zbase)))
  625.                 warned=1;
  626.         }
  627.         value=zuladd(zulmult(value,zbase),digit);
  628.         s++;
  629.         if(*s>='0'&&*s<='9') t=*s-'0'; else{
  630.         if(*s>='a'&&*s<='f') t=*s-'a'+10; else{
  631.         if(*s>='A'&&*s<='F') t=*s-'A'+10; else{t=20;}}}
  632.     }
  633.     while(*s=='u'||*s=='U'||*s=='l'||*s=='L'){
  634.         if(*s=='u'||*s=='U'){
  635.             if(zulleq(value,UINT_MAX)) new->ntyp->flags=UNSIGNED|INT;
  636.              else               new->ntyp->flags=UNSIGNED|LONG;
  637.         }else{
  638.             if(zulleq(value,LONG_MAX)) new->ntyp->flags=LONG;
  639.              else               new->ntyp->flags=UNSIGNED|LONG;
  640.         }
  641.         s++;
  642.     }
  643.     if(*s=='.'||*s=='e'||*s=='E'){
  644.     /*  Fliesskommakonstante, ignoriert vorher berechneten Wert, falls er   */
  645.     /*  nicht dezimal und nicht 0 war (da er dann oktal war)                */
  646.         if(*merk=='0'&&!zuleqto(value,ul2zul(0UL))){
  647.             value=ul2zul(0UL);zbase=ul2zul(10UL);
  648.             while(*merk>='0'&&*merk<='9'){
  649.                 digit=ul2zul((unsigned long)(*merk-'0'));
  650.                 value=zuladd(zulmult(value,zbase),digit);
  651.                 merk++;
  652.             }
  653.             if(merk!=s) error(75);
  654.         }
  655.         db=zul2zd(value);
  656.         if(*s=='.'){
  657.         /*  Teil hinter Kommastellen    */
  658.             zdouble zquot,zbased,digit;
  659.             s++;
  660.             zbased=d2zd(10);zquot=d2zd(0.1);
  661.             while(*s>='0'&&*s<='9'){
  662.                 digit=d2zd((double)(*s-'0'));
  663.                 db=zdadd(db,zdmult(digit,zquot));
  664.                 zquot=zddiv(zquot,zbased);
  665.                 s++;
  666.             }
  667.  
  668.         }
  669.         if(*s=='e'||*s=='E'){
  670.         /*  Exponentialdarstellung  */
  671.             int exp,vorz,i;zdouble zbased;
  672.             zbased=d2zd((double)10);
  673.             s++;
  674.             if(*s=='-'){
  675.                 s++;vorz=-1;
  676.             }else{
  677.                 vorz=1;if(*s=='+') s++;
  678.             }
  679.             exp=0;
  680.             while(*s>='0'&&*s<='9') exp=exp*10+*s++-'0';
  681.             for(i=0;i<exp;i++){
  682.                 if(vorz>0) db=zdmult(db,zbased);
  683.                     else   db=zddiv(db,zbased);
  684.             }
  685.         }
  686.         new->ntyp->flags=DOUBLE;
  687.         if(*s=='f'||*s=='F'){
  688.             new->ntyp->flags=FLOAT;s++;
  689.         }else{
  690.         /*  long double werden nicht unterstuetzt und sind==double :-(  */
  691.             if(*s=='l'||*s=='L') s++;
  692.         }
  693.     }else{
  694.         if(warned) error(211);
  695.         if(new->ntyp->flags==0){
  696.             if(base==10){
  697.                 if(zulleq(value,INT_MAX)) new->ntyp->flags=INT; else{
  698.                 if(zulleq(value,LONG_MAX)) new->ntyp->flags=LONG; else{
  699.                                     new->ntyp->flags=UNSIGNED|LONG;error(212);}}
  700.             }else{
  701.                 if(zulleq(value,INT_MAX)) new->ntyp->flags=INT; else{
  702.                 if(zulleq(value,UINT_MAX))new->ntyp->flags=UNSIGNED|INT; else{
  703.                 if(zulleq(value,LONG_MAX))new->ntyp->flags=LONG; else{
  704.                                    new->ntyp->flags=UNSIGNED|LONG;error(212);}}}
  705.             }
  706.         }
  707.     }
  708.  
  709.     if(new->ntyp->flags==FLOAT) new->val.vfloat=zd2zf(db);
  710.     if(new->ntyp->flags==DOUBLE) new->val.vdouble=db;
  711.     if(new->ntyp->flags==INT) new->val.vint=zl2zi(zul2zl(value));
  712.     if(new->ntyp->flags==(UNSIGNED|INT)) new->val.vuint=zul2zui(value);
  713.     if(new->ntyp->flags==LONG) new->val.vlong=zul2zl(value);
  714.     if(new->ntyp->flags==(UNSIGNED|LONG)) new->val.vulong=value;
  715.     return(new);
  716. }
  717. np identifier_expression(void)
  718. /*  Erzeugt Identifier mit Knoten                           */
  719. {
  720.     np new;char buff[MAXI];
  721.     killsp();cpbez(buff,1);
  722.     new=mymalloc(NODES);
  723.     new->flags=IDENTIFIER;
  724.     new->left=new->right=0;
  725.     new->identifier=add_identifier(buff,strlen(buff));
  726.     new->ntyp=0;
  727.     new->sidefx=0;
  728.     new->val.vlong=l2zl(0L);
  729.     if(new->identifier==empty) {error(76);new->flags=0;}
  730.     return(new);
  731. }
  732. void free_alist(struct argument_list *p)
  733. /*  Gibt argument_list inkl. expressions frei                   */
  734. {
  735.     struct argument_list *merk;
  736.     while(p){
  737.         merk=p->next;
  738.         if(p->arg) free_expression(p->arg);
  739.         free(p);
  740.         p=merk;
  741.     }
  742. }
  743. void free_expression(np p)
  744. /*  Gibt expression mit allen Typen etc. frei                   */
  745. {
  746.     if(!p) return;
  747.     if(p->flags==ASSIGNADD){
  748.         if(!p->right){ierror(0);return;}
  749.         if(p->right->left==p->left)  p->left=0;
  750.         if(p->right->right==p->left) p->left=0;
  751.     }
  752.     if(p->flags==CALL&&p->alist) free_alist(p->alist);
  753.     if(p->ntyp) freetyp(p->ntyp);
  754.     if(p->left) free_expression(p->left);
  755.     if(p->right) free_expression(p->right);
  756.     free(p);
  757. }
  758.  
  759.